package com.ruoyi.commodity.service.impl;

import java.io.File;
import java.util.*;
import java.util.stream.Collectors;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.commodity.domain.*;
import com.ruoyi.commodity.domain.vo.QualityTemplateVO;
import com.ruoyi.commodity.mapper.*;
import com.ruoyi.common.exception.ServiceException;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import com.ruoyi.commodity.service.IQualityTemplateService;
import org.springframework.transaction.annotation.Transactional;

/**
 * 质检模板Service业务层处理
 *
 * @author luxiaoyu
 * @date 2024-11-07
 */
@Service
public class QualityTemplateServiceImpl implements IQualityTemplateService {
	private static final Logger logger = LogManager.getLogger(QualityTemplateServiceImpl.class);

	@Autowired
	private QualityTemplateMapper qualityTemplateMapper;


	@Autowired
	private QualityTemplateItemMapper qualityTemplateItemMapper;

	@Autowired
	private QualityTemplateImagesMapper qualityTemplateImagesMapper;

	@Autowired
	private ProductImagesMapper productImagesMapper;

	@Autowired
	private ProductImageMapper productImageMapper;
	@Value("${ruoyi.profile}")
	private String basePath;

	/**
	 * 查询质检模板
	 *
	 * @param templateId 质检模板主键
	 * @return 质检模板
	 */
	@Override
	public QualityTemplateVO selectQualityTemplateByTemplateId(Long templateId) {
		// 查询单个质量模板
		QualityTemplate qualityTemplate = qualityTemplateMapper.selectQualityTemplateByTemplateId(templateId);

		if (qualityTemplate == null) {
			throw new ServiceException("修改的模板项不存在！请刷新页面重试"); // 如果未找到对应的模板，返回 null 或抛出异常，视业务需求而定
		}

		// 查询该模板对应的质检项
		List<QualityTemplateItem> qualityTemplateItems = qualityTemplateItemMapper.selectList(
				new LambdaQueryWrapper<QualityTemplateItem>()
						.eq(QualityTemplateItem::getTemplateId, templateId)
		);

		// 查询该模板对应的质检模板图片
		List<String> qualityTemplateImages = qualityTemplateImagesMapper.selectList(
						new LambdaQueryWrapper<QualityTemplateImages>()
								.eq(QualityTemplateImages::getTemplateId, templateId)
				).stream()
				.map(QualityTemplateImages::getTemplateImagePath)
				.collect(Collectors.toList());

		// 将查询结果封装到 VO
		QualityTemplateVO qualityTemplateVO = new QualityTemplateVO();
		qualityTemplateVO.setTemplateId(qualityTemplate.getTemplateId());
		qualityTemplateVO.setTemplateName(qualityTemplate.getTemplateName());
		qualityTemplateVO.setCreatedAt(qualityTemplate.getCreatedAt());

		// 设置质检项和质检模板图片
		qualityTemplateVO.setQualityTemplateItems(qualityTemplateItems);
		qualityTemplateVO.setTemplateImagePaths(qualityTemplateImages);

		return qualityTemplateVO;
	}

	/**
	 * 查询质检模板列表
	 *
	 * @param qualityTemplate 质检模板
	 * @return 质检模板
	 */
	@Override
	public List<QualityTemplateVO> selectQualityTemplateList(QualityTemplate qualityTemplate) {
		// 查询模板列表
		List<QualityTemplate> qualityTemplates = qualityTemplateMapper.selectQualityTemplateList(qualityTemplate);

		// 提取所有模板 ID，批量查询质检项和质检模板图片，避免重复查询
		List<Long> templateIds = qualityTemplates.stream()
				.map(QualityTemplate::getTemplateId)
				.collect(Collectors.toList());

		// 检查模板 ID 列表是否为空
		if (templateIds.isEmpty()) {
			return new ArrayList<>(); // 如果为空，直接返回空列表
		}

		// 批量查询质检项并按照模板 ID 分组
		Map<Long, List<QualityTemplateItem>> qualityTemplateItemsMap = qualityTemplateItemMapper.selectList(
				new LambdaQueryWrapper<QualityTemplateItem>()
						.in(QualityTemplateItem::getTemplateId, templateIds)
		).stream().collect(Collectors.groupingBy(QualityTemplateItem::getTemplateId));

		// 批量查询质检模板图片并按照模板 ID 分组
		Map<Long, List<String>> qualityTemplateImagesMap = qualityTemplateImagesMapper.selectList(
				new LambdaQueryWrapper<QualityTemplateImages>()
						.in(QualityTemplateImages::getTemplateId, templateIds)
		).stream().collect(Collectors.groupingBy(
				QualityTemplateImages::getTemplateId,
				Collectors.mapping(QualityTemplateImages::getTemplateImagePath, Collectors.toList())
		));

		// 将查询结果封装到 VO
		return qualityTemplates.stream().map(a -> {
			QualityTemplateVO qualityTemplateVO = new QualityTemplateVO();
			qualityTemplateVO.setTemplateId(a.getTemplateId());
			qualityTemplateVO.setTemplateName(a.getTemplateName());
			qualityTemplateVO.setCreatedAt(a.getCreatedAt());

			// 设置质检项和质检模板图片
			qualityTemplateVO.setQualityTemplateItems(qualityTemplateItemsMap.getOrDefault(a.getTemplateId(), new ArrayList<>()));
			qualityTemplateVO.setTemplateImagePaths(qualityTemplateImagesMap.getOrDefault(a.getTemplateId(), new ArrayList<>()));

			return qualityTemplateVO;
		}).collect(Collectors.toList());
	}


	/**
	 * 新增质检模板
	 *
	 * @param qualityTemplateVO 质检模板
	 * @return 结果
	 */
	@Override
	@Transactional
	public int insertQualityTemplate(QualityTemplateVO qualityTemplateVO) {
		// 插入质检模板数据
		QualityTemplate qualityTemplate = createQualityTemplateFromVO(qualityTemplateVO);
		int templateResult = qualityTemplateMapper.insertQualityTemplate(qualityTemplate);

		Long templateId = qualityTemplate.getTemplateId(); // 拿到插入后的质检模板ID

		// 插入质检模板详细项
		List<QualityTemplateItem> items = qualityTemplateVO.getQualityTemplateItems().stream()
				.map(s -> createQualityTemplateItem(s, templateId))
				.collect(Collectors.toList());

		items.forEach(qualityTemplateItemMapper::insert);

		// 插入质检模板图片
		insertTemplateImages(qualityTemplateVO.getTemplateImagePaths(), templateId);

		return templateResult;
	}

	/**
	 * 创建质检模板对象
	 *
	 * @param qualityTemplateVO 前端传来的VO对象
	 * @return QualityTemplate 实体对象
	 */
	private QualityTemplate createQualityTemplateFromVO(QualityTemplateVO qualityTemplateVO) {
		QualityTemplate qualityTemplate = new QualityTemplate();
		qualityTemplate.setTemplateName(qualityTemplateVO.getTemplateName());
		qualityTemplate.setCreatedAt(new Date());
		return qualityTemplate;
	}

	/**
	 * 创建质检模板详细项
	 *
	 * @param itemVO     前端传来的详细项VO
	 * @param templateId 模板ID
	 * @return QualityTemplateItem 实体对象
	 */
	private QualityTemplateItem createQualityTemplateItem(QualityTemplateItem itemVO, Long templateId) {
		QualityTemplateItem item = new QualityTemplateItem();
		item.setTemplateId(templateId);
		item.setInspectionItem(itemVO.getInspectionItem());
		item.setInspectionContent(itemVO.getInspectionContent());
		item.setCreatedTime(new Date());
		return item;
	}

	/**
	 * 批量插入质检模板图片
	 *
	 * @param templateImagePath 图片路径字符串，逗号分隔
	 * @param templateId        模板ID
	 */
	private void insertTemplateImages(List<String> templateImagePath, Long templateId) {
		if (templateImagePath != null && !templateImagePath.isEmpty()) {
			templateImagePath.stream()
					.map(String::trim)
					.forEach(imagePath -> processImagePath(imagePath, templateId));
		}
	}


	/**
	 * 插入单张质检模板图片
	 *
	 * @param imagePath  图片路径
	 * @param templateId 模板ID
	 */
	private void processImagePath(String imagePath, Long templateId) {
		QualityTemplateImages images = new QualityTemplateImages();
		images.setTemplateId(templateId);
		images.setTemplateImagePath(imagePath);
		images.setCreatedTime(new Date());
		qualityTemplateImagesMapper.insert(images);
	}


	/**
	 * 修改质检模板
	 *
	 * @param qualityTemplateVO 质检模板
	 * @return
	 */
	@Override
	@Transactional
	public int updateQualityTemplate(QualityTemplateVO qualityTemplateVO) {
		// 数据校验
		if (qualityTemplateVO == null || qualityTemplateVO.getTemplateId() == null) {
			throw new ServiceException("质检模板信息不能为空");
		}

		// 查询单个质量模板，确保存在
		QualityTemplate existingTemplate = qualityTemplateMapper.selectQualityTemplateByTemplateId(qualityTemplateVO.getTemplateId());

		if (existingTemplate == null) {
			throw new ServiceException("修改的模板项不存在！请刷新页面重试");
		}

		try {
			// 更新模板基本信息
			QualityTemplate qualityTemplate = new QualityTemplate();
			qualityTemplate.setTemplateId(qualityTemplateVO.getTemplateId());
			qualityTemplate.setTemplateName(qualityTemplateVO.getTemplateName());
			// 设置其他需要更新的字段，如更新时间等
			qualityTemplate.setUpdatedAt(new Date());

			int result = qualityTemplateMapper.updateQualityTemplate(qualityTemplate);

			// 删除旧的关联数据
			Long templateId = qualityTemplateVO.getTemplateId();
			qualityTemplateItemMapper.delete(
					new LambdaQueryWrapper<QualityTemplateItem>()
							.eq(QualityTemplateItem::getTemplateId, templateId)
			);

			// 获取要删除的旧图片路径
			List<QualityTemplateImages> oldImages = qualityTemplateImagesMapper.selectList(
					new LambdaQueryWrapper<QualityTemplateImages>()
							.eq(QualityTemplateImages::getTemplateId, templateId)
			);
			List<String> oldImagePaths = oldImages.stream()
					.map(QualityTemplateImages::getTemplateImagePath)
					.collect(Collectors.toList());

			qualityTemplateImagesMapper.delete(
					new LambdaQueryWrapper<QualityTemplateImages>()
							.eq(QualityTemplateImages::getTemplateId, templateId)
			);


			// 插入新的质检项
			List<QualityTemplateItem> newItems = qualityTemplateVO.getQualityTemplateItems();
			if (newItems != null && !newItems.isEmpty()) {
				for (QualityTemplateItem item : newItems) {
					item.setTemplateId(templateId);
					item.setCreatedTime(new Date());
					// 设置其他需要的字段
					qualityTemplateItemMapper.insert(item);
				}
			}

			// 插入新的图片路径
			List<String> newImagePaths = qualityTemplateVO.getTemplateImagePaths();
			if (newImagePaths != null && !newImagePaths.isEmpty()) {
				for (String imagePath : newImagePaths) {
					QualityTemplateImages image = new QualityTemplateImages();
					image.setTemplateId(templateId);
					image.setTemplateImagePath(imagePath);
					image.setCreatedTime(new Date());
					// 设置其他需要的字段
					qualityTemplateImagesMapper.insert(image);
				}
			}

			// 比较旧图片和新图片，找出需要删除的物理文件
			List<String> imagesToDelete = oldImagePaths.stream()
					.filter(path -> !newImagePaths.contains(path))
					.collect(Collectors.toList());

			// 删除不再使用的物理图片文件
			deleteImageFiles(imagesToDelete);

			return result;
		} catch (Exception e) {
			logger.error("更新质检模板失败，模板ID：" + qualityTemplateVO.getTemplateId(), e);
			throw new ServiceException("更新质检模板失败：" + e.getMessage());
		}
	}


	/**
	 * 批量删除质检模板
	 *
	 * @param templateIds 需要删除的质检模板主键
	 * @return 结果
	 */
	@Override
	@Transactional
	public int deleteQualityTemplateByTemplateIds(Long[] templateIds) {
		// 将数组转换为列表，方便后续操作
		List<Long> templateIdList = Arrays.asList(templateIds);

		// 1. 查询需要删除的模板，确保它们存在
		List<QualityTemplate> templatesToDelete = qualityTemplateMapper.selectBatchIds(templateIdList);
		if (templatesToDelete.size() != templateIds.length) {
			throw new ServiceException("部分模板不存在，无法删除，请刷新页面重试");
		}

		// 2. 收集所有需要删除的图片路径
		List<QualityTemplateImages> imagesToDelete = qualityTemplateImagesMapper.selectList(
				new LambdaQueryWrapper<QualityTemplateImages>()
						.in(QualityTemplateImages::getTemplateId, templateIdList)
		);
		List<String> imagePathsToDelete = imagesToDelete.stream()
				.map(QualityTemplateImages::getTemplateImagePath)
				.collect(Collectors.toList());

		// 3. 删除关联的质检项
		qualityTemplateItemMapper.delete(
				new LambdaQueryWrapper<QualityTemplateItem>()
						.in(QualityTemplateItem::getTemplateId, templateIdList)
		);

		// 4. 删除关联的图片记录
		qualityTemplateImagesMapper.delete(
				new LambdaQueryWrapper<QualityTemplateImages>()
						.in(QualityTemplateImages::getTemplateId, templateIdList)
		);

		// 5. 删除模板本身
		int result = qualityTemplateMapper.deleteQualityTemplateByTemplateIds(templateIdList.toArray(new Long[0]));

		// 6. 删除物理图片文件
		deleteImageFiles(imagePathsToDelete);

		return result;
	}



	// 在删除物理图片文件之前，检查图片是否仍被引用
	private void deleteImageFiles(List<String> imagePaths) {
		if (imagePaths == null || imagePaths.isEmpty()) {
			return;
		}
		for (String imagePath : imagePaths) {
			// 移除 imagePath 中的 '/profile' 前缀
			String prefixToRemove = "/profile";
			String adjustedImagePath = imagePath;
			if (imagePath.startsWith(prefixToRemove)) {
				adjustedImagePath = imagePath.substring(prefixToRemove.length());
			}

			// 检查该图片是否仍被其他模板引用
			int count = productImagesMapper.selectCount(
					new LambdaQueryWrapper<ProductImages>()
							.eq(ProductImages::getImagePath, imagePath)
			).intValue();

			if (count == 0) {
				// 没有其他引用，可以删除物理文件
				File file = new File(basePath + adjustedImagePath);
				if (file.exists() && file.isFile()) {
					boolean deleted = file.delete();
					if (!deleted) {
						// 记录警告日志，但不抛出异常
						logger.warn("删除图片文件失败：" + file.getAbsolutePath());
					} else {
						logger.info("成功删除图片文件：" + file.getAbsolutePath());
					}
				} else {
					// 文件不存在，记录信息日志
					logger.info("图片文件不存在或不是文件，无需删除：" + file.getAbsolutePath());
				}
			} else {
				// 仍有引用，不删除物理文件，记录信息日志
				logger.info("图片仍被引用，未删除文件：" + imagePath);
			}
		}
	}
}
